const cloud = require('@cloudbase/node-sdk')

// 初始化云开发实例
const app = cloud.init({
    env: cloud.SYMBOL_CURRENT_ENV
})

// 获取数据库引用
const db = app.database()
const collection = db.collection('resume_model')

/**
 * resume_model CRUD 云函数
 * @param {Object} event - 云函数参数
 * @param {Object} context - 云函数上下文
 */
exports.main = async (event, context) => {
    const { action, data } = event

    try {
        // 操作日志
        console.log('resume-model-crud 调用:', { action, data })

        switch (action) {
            case 'create':
                return await createModel(data)
            case 'read':
                return await getModel(data)
            case 'update':
                return await updateModel(data)
            case 'delete':
                return await deleteModel(data)
            case 'list':
                return await listModels(data)
            default:
                throw new Error('无效的操作类型')
        }
    } catch (error) {
        console.error('resume-model-crud 错误:', error)
        return {
            code: -1,
            message: error.message,
            data: null
        }
    }
}

/**
 * 创建简历模型
 * @param {Object} data - 模型数据
 * @param {string} data.name - 模型名称
 * @param {string} data.fileId - 文件ID
 * @param {boolean} data.enable - 是否启用
 */
async function createModel(data) {
    const { name, fileId, enable = true } = data

    if (!name) {
        throw new Error('名称为必填项')
    }

    if (!fileId) {
        throw new Error('文件ID为必填项')
    }

    // 验证名称长度
    if (name.length < 1 || name.length > 50) {
        throw new Error('名称长度应为1-50个字符')
    }

    const result = await collection.add({
        name,
        fileId,
        enable,
        createdAt: new Date(),
        updatedAt: new Date()
    })

    return {
        code: 0,
        message: '创建成功',
        data: result
    }
}

/**
 * 获取单个模型
 * @param {Object} data - 查询参数
 * @param {string} data._id - 模型ID
 */
async function getModel(data) {
    const { _id } = data

    if (!_id) {
        throw new Error('ID为必填项')
    }

    const result = await collection.doc(_id).get()

    if (!result.data || result.data.length === 0) {
        throw new Error('模型不存在')
    }

    return {
        code: 0,
        message: '查询成功',
        data: result.data[0]
    }
}

/**
 * 更新模型
 * @param {Object} data - 更新数据
 * @param {string} data._id - 模型ID
 * @param {string} [data.name] - 模型名称
 * @param {string} [data.fileId] - 文件ID
 * @param {boolean} [data.enable] - 是否启用
 */
async function updateModel(data) {
    const { _id, name, fileId, enable } = data

    if (!_id) {
        throw new Error('ID为必填项')
    }

    const updateData = {
        updatedAt: new Date()
    }

    if (name !== undefined) {
        // 验证名称长度
        if (name.length < 1 || name.length > 50) {
            throw new Error('名称长度应为1-50个字符')
        }
        updateData.name = name
    }

    if (fileId !== undefined) updateData.fileId = fileId
    if (enable !== undefined) updateData.enable = enable

    const result = await collection.doc(_id).update(updateData)

    return {
        code: 0,
        message: '更新成功',
        data: result
    }
}

/**
 * 删除模型
 * @param {Object} data - 删除参数
 * @param {string} data._id - 模型ID
 */
async function deleteModel(data) {
    const { _id } = data

    if (!_id) {
        throw new Error('ID为必填项')
    }

    const result = await collection.doc(_id).remove()

    return {
        code: 0,
        message: '删除成功',
        data: result
    }
}

/**
 * 获取模型列表
 * @param {Object} data - 查询参数
 * @param {number} [data.page=1] - 页码
 * @param {number} [data.pageSize=10] - 每页数量
 * @param {boolean} [data.enable] - 是否启用筛选
 * @param {string} [data.name] - 名称筛选
 */
async function listModels(data) {
    const { page = 1, pageSize = 10, enable, name, _id } = data

    // 构建查询条件
    let queryCondition = {}

    // 按ID精确查询
    if (_id) {
        queryCondition._id = _id
    }

    // 按名称模糊查询
    if (name) {
        queryCondition.name = db.RegExp({
            regexp: name,
            options: 'i' // 不区分大小写
        })
    }

    // 按启用状态筛选
    if (enable !== undefined) {
        queryCondition.enable = enable
    }

    console.log('查询条件:', JSON.stringify(queryCondition))

    // 创建查询对象
    const query = collection.where(queryCondition)

    const result = await query
        .orderBy('createdAt', 'desc')
        .skip((page - 1) * pageSize)
        .limit(pageSize)
        .get()

    const countResult = await query.count()

    return {
        code: 0,
        message: '查询成功',
        data: {
            list: result.data,
            total: countResult.total,
            page,
            pageSize
        }
    }
}
